Multisource semantic partitioning

ABSTRACT

Methods, systems, and computer program products for processing a query to determine query results. The query may be analyzed to determine a constant column pair corresponding to the query. The column constant pair may be analyzed with respect to a column constant pair associated with a partitioned data set in order to route the query to a subset of the data set. Data sets may be partitioned into subsets by analyzing historical queries to determine a partitioning column constant pair with respect to the data set that is used to partition the data of the data set into subsets. The query processing may include both query routing and data set partitioning.

BACKGROUND

The present invention relates to database and database managementsystems, and more particularly to data federation.

A data federation system is a type of database management system (DBMS).In a data federation system, a federation engine may be coupled to aplurality of external data sources from which the federation engine mayaccess data. A query for data stored in the plurality of external datasources may be received by the federation engine from a first client ofa plurality of clients and distributed to the plurality of data sources.

A data federation system may be optimized by caching result sets on thefederated engine, such that the federated engine may reduce the sendingof sub-queries to the plurality of external data sources. The federationengine may also create one or more re-usable “virtual” views on thefederation engine that store one or more result sets that the client mayquery.

The federation engine typically requires high query throughput becausethe federation engine is the access point for the plurality of clientsto send a large number of queries to the plurality of external datasources. Accordingly, a limiting factor for query processing is thequery throughput of the federation engine.

BRIEF SUMMARY

According to one embodiment a computer-implemented method for federatedquery processing comprises: receiving one or more source queriesassociated with a data set; storing the one or more source queries asone or more historical queries; determining one or more column constantpairs associated with the one or more historical queries; based on theone or more column constant pairs, determining a partitioning columnconstant pair; determining a first subset of the one or more columnconstant pairs that has a first pre-defined relation to the partitioningcolumn constant pair; determining a second subset of the one or morecolumn constant pairs that has a second pre-defined relation to thepartitioning column constant pair; based on the partitioning columnconstant pair, partitioning the data set into a first subset of the dataset and a second subset of the data set; receiving a source query;determining a source column constant pair associated with the sourcequery; comparing the source column constant pair to the partitioningcolumn constant pair; and based on the comparing, determining a resultof the source query from at least one of the following: a view, thefirst subset of the data set, and the second subset of the data set.

According to another embodiment a non-transitory computer-readablemedium for query processing comprises computer-readable instructions,the computer-readable instructions executable by a processor to causethe processor to: receive a source query; determine a source columnconstant pair associated with the source query; determine a partitioningcolumn constant pair associated with a data set; compare the sourcecolumn constant pair to the partitioning column constant pair; and basedon the comparison, determine a result of the source query from at leastone of the following: a view, a first subset of the data set, and asecond subset of the data set.

According to yet another one embodiment a federated system for queryprocessing, comprises: at least one processor in communication with amemory; a source router communicatively coupled to one or more datasources; the source router executable by the at least one processor to:receive a source query; determine a source column constant pairassociated with the source query; compare the source column constantpair to a partitioning column constant pair that is associated with adata set; and based on the comparison, determine a result of the sourcequery from at least one of the following: a view, a first subset of thedata set that is stored on a first data source of the one or more datasources, and a second subset of the data set that is stored on a seconddata source of the one or more data sources.

BRIEF DESCRIPTION OF THE DRAWINGS

Various examples of the present disclosure will be understood more fullyfrom the detailed description given below and from the accompanyingdrawings of various examples of the disclosure.

FIG. 1 is a block diagram illustrating a federated system architecture,in accordance with various examples of the present disclosure.

FIG. 2 is a block diagram illustrating query processing, according to anexample of the present disclosure.

FIG. 3 is a flow diagram illustrating data partitioning, according to anexample of the present disclosure.

FIG. 4 is a flow diagram illustrating query routing, in accordance withvarious examples of the present disclosure.

FIG. 5 is a block diagram illustrating an exemplary computer system thatmay perform one or more of the operations described herein.

DETAILED DESCRIPTION

In the following description, specific details are set forth describingsome embodiments consistent with the present disclosure. It will beapparent, however, to one skilled in the art that some embodiments maybe practiced without some or all of these specific details. The specificembodiments disclosed herein are meant to be illustrative but notlimiting. One skilled in the art may realize other elements that,although not specifically described here, are within the scope and thespirit of this disclosure. In addition, to avoid unnecessary repetition,one or more features shown and described in association with oneembodiment may be incorporated into other embodiments unlessspecifically described otherwise or if the one or more features wouldmake an embodiment non-functional.

FIG. 1 illustrates an exemplary federated system architecture 100 inwhich examples of the present disclosure can be implemented. Infederated system architecture 100, client 102, data sources 120, 122 and124, and data federation tool 104 are communicatively coupled viaconnections 106, 108, 110 and 112 that represent any combination orphysical and/or wireless connections. Each connection may be part of anetwork. A network may be a public network (e.g., the Internet), aprivate network (e.g., a local area network (LAN) or wide area network(WAN)), or a combination thereof. In an example, the network may includethe Internet and/or one or more intranets, landline networks, wirelessnetworks, and/or other appropriate types of communication networks. Inan example, the network may comprise a wireless telecommunicationsnetwork (e.g., cellular phone network) adapted to communicate with othercommunication networks, such as the Internet.

Client 102 may be a user machine, such as a personal computer (PC), atablet PC, a set-top box (STB), a Personal Digital Assistant (PDA), acellular telephone, a web appliance, an enterprise server, a networkrouter, switch or bridge, or any machine capable of executing a set ofinstructions (sequential or otherwise). Further, while one client isillustrated, the term client shall also be taken to include anycollection of computing devices that individually or jointly execute aset (or multiple sets) of instructions to perform any one or more of themethodologies discussed herein.

Client 102 may run an operating system (OS) that manages hardware andsoftware of the respective user machine. The operating system may be anystandard or proprietary OS. A browser may run on the OS of a client. Thebrowser may be a web browser that can access content and servicesprovided by data federation tool 104. Further, other types of softwareapplications (e.g., applications, mobile applications, “apps”) runningon client 102 may provide access to content and services of datafederation tool 104 without the use of a browser and/or without activehuman interaction.

In the present example, data sources 120, 122 and 124 may each be one ormore computing devices, such as personal computers (PCs), webappliances, enterprise servers, or any machines capable of executing aset of instructions (sequential or otherwise). Data sources 120, 122 and124 may each be configured with access to one or more standard orproprietary data stores. For example, a data store may be a flat file, aweb service, or a relational database, such as an SQL-compliantdatabase. Data stores may be homogenous or heterogeneous (e.g., datasource 120 may be associated with an SQL-compliant database data store,data source 122 may be associated with a web service data store and datasource 124 may be associated with a flat file data store).

Each data source may be structured with one or more applications thatreceive queries from data federation tool 104, process the queries toretrieve results from the appropriate one or more data stores and returnthe results of the queries to data federation tool 104. In the presentexample, the applications on a data source may comprise a relationaldatabase management system. In one example, an interface such as a JavaDatabase Connectivity (JDBC) API may be implemented on a data sourceusing a JDBC driver, in order for the data source to retrieve data fromthe data store associated with the data source by processing queriesfrom data federation tool 104 that conform to the specifications of theJDBC interface.

In the present example, data federation tool 104 is structured as afederated database management system for processing queries. Datafederation tool 104 may be software stored in one or more computerreadable storage media and executed by one or more server machines thatindividually or jointly execute a set (or multiple sets) of instructionsto perform any one or more of the methodologies discussed herein.Examples of server machines include enterprise servers, personalcomputers (PCs), and any machines capable of executing a set ofinstructions (sequential or otherwise).

Data federation tool 104 is structured to receive a federated query froma client (e.g., client 102), parse the federated query into sub-queries(e.g., a first sub-query for a first data source 120, a second sub-queryfor a second data source 122 and a third sub-query for a third datasource 124), retrieve results for the sub-queries from the data sources,aggregate the sub-query results and present the aggregated sub-queryresults to the client.

Re-usable “virtual” views may be created by data federation tool 104 inorder to store aggregated results of the sub-queries locally by datafederation tool 104 such that future queries of the data in the view maybe processed by data federation tool 104 accessing the view directlyrather than by sending sub-queries to data sources and aggregating thesub-query responses.

In the present example, data federation tool 104 includes query engine114, query sampler 116, query database 118, source router 126 andmultisource partitioner 128.

In the present example, query engine 114, query sampler 116, sourcerouter 126 and multisource partitioner 128 may be implemented assoftware modules that are stored on a machine (e.g., the data federationtool 104 server machine) and executed via one or more processors. Querydatabase 118 may be a database such as an SQL-compliant database. Inanother example, query database 118 may be another type of data store,such as a flat file or a web service. Query database 118 may be storedon a server machine that is local or external to the data federationtool 104.

Query engine 114 is structured to receive and process queries fromclient 102, such as federated queries. These federated queries may beprocessed by generating sub-queries of the federated queries, which arereferred to as source queries. Query sampler 116 is communicativelycoupled to query engine 114, in order to receive source queries fromquery engine 114. Query sampler 116 is communicatively coupled to querydatabase 118 and source router 126. Query sampler 116 is structured tostore the source queries into query database 118.

Source router 126 is communicatively coupled to data sources 120, 122and 124, such that source router 126 is structured to receive sourcequeries from query sampler 116 and send the source queries to a view orto the one or more data sources for processing. The view may beconfigured, for example by a data architect, to store result data setsfrom the data sources locally on data federation tool 104.

Multisource partitioner 128 is communicatively coupled to query database118 and data sources 120, 122 and 124. Multisource partitioner 128 isstructured to perform analysis of historical queries stored in querydatabase 118, in order to partition data on data sources 120, 122 and124 into various data set configurations to optimize the data sets suchthat query responses may be determined more efficiently.

Query engine 114, query sampler 116, query database 118, source router126 and multisource partitioner 128 allow data federation tool 104 toprocess queries more efficiently, which improves the functionality ofthe client machine(s), server machine(s) and data source machine(s) infederated system 100. For example, queries may be processed faster,thereby increasing query throughput.

FIG. 2 is a block diagram illustrating query processing, according to anexample of the present disclosure. The architecture 200 may comprisehardware (e.g., circuitry, dedicated logic, programmable logic andmicrocode), software (such as instructions run on a computer system,specialized hardware, dedicated machine, or processing device),firmware, or a combination thereof that performs one or more methods forquery processing.

A federated query 202 may originate from a client and be sent the datafederation tool 220. The query may be referred to as “federated” becausethe query may contain component parts that may be parsed into one ormore sub-queries.

Federated query 202 may request data from one or more data sets that areaccessible to data federation tool 220. The data sets may be storedlocally to data federation tool 220 or stored externally on one or moredata sources.

At 204, the federated query 202 is received from the client by queryengine 204 at data federation tool 220. Query engine 204 may parse thefederated query to generate sub-queries that are referred to as sourcequeries. In another example, the parsing and generating of sub-queriesmay be performed by decomposing the federated query into componentsub-parts, based on how data is allocated by data sources. For example,if the federated query requests data from a data table stored on a firstdata source and data from a data table stored on a second data source,the federated query may be decomposed into a first source query thatrequests data from the data table of the first data source and a secondsource query that requests data from the data table of the second datasource.

The source queries may be components of the federated query such thatthe query responses to the source queries may be aggregated to determinea result set corresponding to the federated query. Once the sourcequeries are generated, the source queries are sent from query engine 204and received by query sampler 206. In another example, the sourcequeries may be sent by query engine 204 to source router 208, with querysampler 206 intercepting the source queries. Intercepting may beperformed by query sampler 206 monitoring query engine 204 to determinesource queries.

Query sampler 206 may process source queries by sending the sourcequeries to query database 210 for storage as historical queries. Querysampler 206 may determine additional statistics relating to historicalqueries. The statistics may comprise size information relating to eachhistorical query, such as the response size for each historical query,the processing time of each historical query, and so forth. Responsesize may be measured using a variety of metrics, including size asmeasured by bytes (and other unit variations such as kilobytes andmegabytes), number of elements retrieved, number of columns, number ofrows, and so forth.

In another example, query sampler 206 may store only a subset of thesource queries as historical queries. For example, a subset of sourcequeries may be source queries from a pre-determined time period such assource queries within the past six months. In another example, thesubset of the source queries may be source queries that occur within aparticular time window, such as source queries within 5 ms of oneanother.

The statistics for each historical query may be stored in query database210 in association with each corresponding historical query. Forexample, once a query response is received from a data sourcecorresponding to a first source query, the size of the response to thefirst source query may be measured and the size stored in associationwith the historical query corresponding to the first source query inquery database 210.

Source router 208 may receive each source query from query engine 204 orquery sampler 206, depending upon whether query engine 204 is structuredto send the source query to source query 208 or to query sampler 206. Aspreviously discussed, query engine 204 may be structured to send thesource query with source router 208 with query sampler 206 interceptingthe source query.

In the present example, source router 208 may process the source queryafter the source query is sent to query database 210 for storage. Inanother example, the source query may be sent to source router 210 inparallel or prior to the source query being stored in query database 210as a historical query.

Source router 208 processes the source query using routing logic toroute the query to a view or a data source. In the present example, thesource query pertains to data stored in a PERSON data table. In thepresent example, the data from the PERSON data table is partitioned intotwo subset data tables, PERSON_PART_A 216 and PERSON_PART_B 218, each ofwhich is stored a data table separate from the PERSON data table on adifferent data source from one another.

In the present example, a federated view PERSON_VIEW 214 contains thedata of the PERSON data table and is stored on data federation tool 220.PERSON_VIEW 214 may be an optimization of data federation tool 220 thatallows data federation tool 220 to access data from the view locally andreturn source query responses to clients without having to send sourcequeries to external data sources.

In the present example, the source query is a request for data from thePERSON data table. Accordingly, source router 208 optimizes the sourcequery by selecting between the PERSON data table, PERSON_VIEW 214,PERSON_PART_A 216 and PERSON_PART_B 218.

The analysis for selecting the optimal data store for which to route thesource query is discussed further regarding FIG. 4.

If source router 208 determines that the source query is to be routed toPERSON_VIEW 214, then the source query is processed by data federationtool 220 retrieving data results from PERSON_VIEW at 214. Any statisticsrelating to the source query, such as the size of the source queryresponse that includes the data results may be stored in query database210 with the historical query corresponding to the source query. Thesource query data results that are retrieved from PERSON_VIEW 214 may beaggregated with any other source query data results pertaining to thereceived federated query. The aggregated source query data results maybe returned to the client by data federation tool 220 as a response tofederated query 202.

If source router 208 determines that the source query is to be routed toPERSON_PART_A 216, then the source query is processed by sending thesource query to a first data source that is associated withPERSON_PART_A 216. The first data source receives the source query andprocesses the source query to retrieve the source query results fromPERSON_PART_A 216. In the present example, PERSON_PART_A 216 may be adata table that is stored on the first data source, wherein the tablestores a first subset of the data from the PERSON data table. Anystatistics relating to the source query, such as the size of the sourcequery response that includes the data results may be stored in querydatabase 210 with the historical query corresponding to the sourcequery. The size of the source query response may be measured by thefirst data source or by data federation tool 220. The source query dataresults that are retrieved from PERSON_PART_A 216 may be sent to thedata federation tool 220 for aggregation by data federation tool 220with any other source query data results pertaining to the receivedfederated query. The aggregated source query data results may bereturned to the client by data federation tool 220 as a response tofederated query 202.

If source router 208 determines that the source query is to be routed toPERSON_PART_B 218, then the source query is processed by sending thesource query to a second data source that is associated withPERSON_PART_B 218. The second data source receives the source query andprocesses the source query to retrieve the source query results fromPERSON_PART_B 218. In the present example, PERSON_PART_B 218 may be adata table that is stored on the second data source, wherein the tablestores a second subset of the data from the PERSON data table. Anystatistics relating to the source query, such as the size of the sourcequery response that includes the data results may be stored in querydatabase 210 with the historical query corresponding to the sourcequery. The size of the source query response may be measured by thesecond data source or by data federation tool 220. The source query dataresults that are retrieved from PERSON_PART_B 218 may be sent to thedata federation tool 220 for aggregation by data federation tool 220with any other source query data results pertaining to the receivedfederated query. The aggregated source query data results may bereturned to the client by data federation tool 220 as a response tofederated query 202.

Multisource partitioner 212 is executed periodically to analyze thehistorical queries stored in query database 210, in order to determineoptimal allocation of data in one or more views and data sources.Multisource partitioner 212 may operate in parallel to the queryprocessing operations performed by the other components such as queryengine 204, query sampler 206 and source router 208. In another example,multisource partitioner 212 may be scheduled to run at other times, suchas non-peak times. The periodic execution of multisource partitioner 212may be pre-defined based on a user configured time-increment orschedule. In another example, data federation tool 220 may scheduleexecution of multisource partitioner 212 on the basis of activitydetermined by data federation tool 220.

The analysis for determining the optimal allocation of data bymultisource partitioner 212 is discussed further regarding FIG. 3.

In the present example, based on the analysis, multisource partitioner212 may partition PERSON_PART_A 216 and PERSON_PART_B 218 by joining thedata subsets and/or by splitting the data into different data subsets.For example, data subsets that were previously partitioned may be joinedinto a single data set, and the data set analyzed to determine a newoptimal partitioning of the data set into a first subset of the data setand a second subset of the data set that are different from thepreviously determined subsets of the data set.

An example of joining is combining PERSON_PART_A 216 and PERSON_PART_B218 into a single data set (e.g., PERSON) that contains the data fromboth PERSON_PART_A 216 and PERSON_PART_B 218. An example of splitting isdetermining two subsets of the data set stored in the PERSON data table,and storing each subset in a separate data table (e.g., PERSON_PART_A216 and PERSON_PART_B 218). Further, each subset of the data set may befurther split, such as splitting PERSON_PART_B 218 into two subsets(e.g., PERSON_PART_C and PERSON_PART_D).

FIG. 3 is a flow diagram illustrating data partitioning, according to anexample of the present disclosure. The method 300 may be performed byprocessing logic that may comprise hardware (e.g., circuitry, dedicatedlogic, programmable logic and microcode), software (such as instructionsrun on a computer system, specialized hardware, dedicated machine, orprocessing device), firmware, or a combination thereof.

In the present example, data partitioning is performed by a multisourcepartitioner. Multisource partitioner may perform data partitioning on atable by table basis, starting with a first table and moving to a nexttable once the first table is finished partitioning. In another example,tables may be partitioned concurrently.

At block 301, the multisource partitioner retrieves one or morehistorical queries from a query database. Multisource partitioneranalyzes the historical queries and their associated historical querystatistics that are stored in a query database pertaining to aparticular table. Historical query statistics may include statisticspertaining to historical queries, such as the sizes of the historicalqueries. A size of a historical query may be, for example, the size ofthe query response for the historical query. In the present example,query response size may correspond to size as measured in any of bytes,kilobytes and megabytes. In another example, size may be a measurementof the total number of results in the query response. Various other sizemetrics may be used in addition to the examples given. The size of thequery response for the historical query may be measured by the datasource that determined the query response. In another example, the sizeof the query response for the historical query may be measured by thedata federation tool upon receiving the query response from the datasource. In another example, the size of the query response for thehistorical query may be measured by the data federation tool upondetermining the query response from a federated view.

At block 302, the multisource partitioner determines (i) historicalqueries that have an OR condition pertaining to two data stores, whichwill be referred to as QO and (ii) historical queries that have an ANDcondition, will be referred to as QA.

The sizes of the QO historical queries may be aggregated and compared tothe aggregated size of the QA historical queries.

At block 304, if the size of QO is greater than the size of QA, then thedata from the two data stores may be joined into a single data store.For example, if there is a PEOPLE data table that was previouslypartitioned into PEOPLE_A and PEOPLE_B subset data tables, thepartitions may be joined into a single PEOPLE data table. In anotherexample, the data from the subset data stores may be joined if the sizeof QO is greater than or equal to the size of QA.

At block 306 the historical queries are analyzed to determine whether apartitioning column constant pair, (C, K), exists for partitioning thedata in each data store to optimize query processing. In the presentexample, the partitioning column constant pair represents a column andconstant that are used to partition data into subsets.

The determining of a partitioning column constant pair for thehistorical queries pertaining to a data store is performed by analysisof the one or more column constant pairs of the historical queries. Inthe present example, the column constant pairs for each historical queryare retrieved from the query database. The column constant pairs foreach historical query may be determined and stored in the query databaseas the source queries corresponding to the historical queries areprocessed. In another example, column constant pairs may be determinedfor the historical queries before, during or after historical queriesare retrieved from the query database.

Column constant pairs for a historical query may be determined asillustrated in the following SQL example.

An SQL formatted historical query may be: “SELECT name FROM people WHEREage <30 and gender=‘male.’” Accordingly, the two following columnconstant pairs may be determined for the historical query with respectto the “people” data store based on the WHERE clause: (age, 30) and(gender, male). Each column constant pair may be a tuple, as shown. Inanother example, the column and constant may be represented by anotherdata structure, such as a linked list, and/or stored in an alternateformat.

The column constant pairs of the historical queries for data in the dataset stored by the data store are analyzed, such as by a brute forcealgorithm, to determine a partitioning column constant pair comprising acolumn C and a constant K, such that (i) historical queries with columnconstant pairs that have a first pre-defined “less than or equal to”relation to the partitioning column constant pair will returnapproximately a first pre-defined amount of the size of historicalqueries with a second pre-defined “greater than” relation to thepartitioning column constant pair and (ii) the size of historicalqueries incomparable to the partitioning column constant pair is asecond pre-defined amount of the size of the total size of the datareturned by all historical queries with respect to the data store. Inanother example, the determining of the partitioning column constantpair may use an algorithm other than a brute-force algorithm thatevaluates every historical query with respect to the data store.Examples of other algorithms that may be used include recursive “divideand conquer” algorithms and sorting algorithms such as merge sort,heapsort, quicksort, bubble sort and distribution sort.

In another example, instead of “less than or equal to” and “greaterthan,” the relation between the column constant pairs of the historicalqueries and the determined partitioning column constant pair may insteadbe “less than” and “greater than or equal to.”

In the present example, the first pre-defined amount may be a sizedifference between +10% or −10%. For example, the historical querieswith column constant pairs less than or equal to the partitioning columnconstant pair may be within 10% of the size of historical queries withcolumn constant pairs that are greater than the partitioning columnconstant pair. In another example, a different pre-defined amount may beconfigured. Setting the first-predefined amount to a difference of +10%or −10% may help ensure an approximately even split of the data in adata set of a data store into two subsets of the data set.

In the present example, the second pre-defined amount may be a sizedifference of 10% or less of the total size of the historical querieswith respect to the data store. Accordingly, the data in a data set maybe split such that the size of the historical queries have columnconstant pairs that are incomparable to the partitioning column constantpair is relatively small compared to the total size of the historicalqueries with respect to the data store.

Column constant pairs (age, 20) and (age, 30) are examples of columnconstant pairs that are less than or equal to a partitioning columnconstant pair (age, 30).

A column constant pair (age, 31) is an example of a column constant pairthat is greater than a partitioning column constant pair (age, 30).

Accordingly, in the present example, if the partitioning column constantpair is determined to be (age, 30), the data of a data set in a datastore may be split such that data values of 30 or less in the age columnare placed in a first data table as a first subset of the data set, anddata values above 30 in the age column are placed in a second data tableas a second subset of the data set.

For strings, less than or equal may relations include any strings thatare the same, because of the or equal clause. Strings that are not equalmay be considered as “greater” by default as the strings are notincluded in the less than or equal to relation. For example, a columnconstant pair (gender, male) is less than or equal to the columnconstant pair (gender, male). The column constant pair (gender, female)is greater than (gender, male) by default, since (gender, female) is not“less than or equal to” (gender, male).

Similarly, for strings there are various relations that may be usedrather than “less than or equal to” and “greater than.” For example, therelation may be “equal to” or “not equal to” or “less than” and “greaterthan or equal to.” In another example, strings may be converted tonumbers such that a less than or greater than relationship may bedetermined for the strings.

Column constant pairs may be determined to be incomparable to apartitioning column constant pair as well. A column constant pair(gender, %ale) is an example of a column constant pair that isincomparable to either (gender, male) or (gender, female). In SQL, %represents a wild card character. Therefore, %ale may refer to eithermale or female. As such, %ale may be determined to be incomparable to“male” and “female” as %ale refers to both “male” and “female.”

At block 308, if no partitioning column constant pair is determined toexist that meets the pre-defined relation for a data table that waspreviously split into two subset data tables, then the data from thesubset data tables are joined into a single data table. If the subsettables for the data table are already joined then the method ends.

At block 310, if a partitioning column constant pair is determined toexist that meets the pre-defined relation, in this example the size ofthe historical queries that are “less than or equal to” the partitioningcolumn constant pair is within 10% of the size of the historical queriesthat are “greater than” the partitioning column constant pair, then thetable is partitioned using the partitioning column constant pair, withdata having values in the column C that are less than or equal to Kbeing placed into a first subset data table, and data having values inthe column C greater than K being placed into a second subset table.Accordingly, the data of the data table is split into a first subset ofthe data set that is placed into a first sub-table and a second subsetof the data set that is placed into a second sub-table.

The partitioning may be performed on sub-tables as well, for exampleusing recursion, in order to further partition data from the sub-tablesinto sub-tables of the sub-tables. Tables and sub-tables may be movedbetween data sources as well, to optimize query processing. For example,a first data source may be determined to have a heavy query loadcompared to a second data source. A subset of the data from the firstdata source may be placed into a sub-table that is moved to the seconddata source, in order to load-balance the query processing among thedata sources.

Once the partitioning column constant pair is determined forpartitioning of the table and/or sub-tables, the partitioning columnconstant pair may be associated with the tables and sub-tables such thatone or more future queries are routed to the tables based on the columnconstant pairs associated with the future queries. For example, a datatable that is partitioned may be associated with the partitioning columnconstant pair, the first subset data table may be associated with thedata that is less than or equal to the partitioning column constantpair, and the second subset data table may be associated with the datathat is greater than the partitioning column constant pair. Theassociations between the data tables and the partitioning columnconstant pair may be stored in a data store, such as a relationaldatabase. In another example, the partitioning column constant pair maybe associated with a table or sub-table by storing the partitioningcolumn constant pair in the metadata of the table or sub-table.

Query routing based on the partitioning column constant pair isdiscussed further regarding FIG. 4.

The goal of the data partitioning may be to group the data into evenlydistributed subsets based on the typical usage of the data federationtool as determined by analyzing the historical queries. Such evenlydistributed groupings may provide for faster data retrieval as there isless data in each table to search through in order to determine resultsto a query.

In another example, the goal may be to determine the data that is mostfrequently accessed, such that the frequently accessed data is locatedin a different table than the data that is infrequently accessed.

The pre-defined relations may be configured, such as by a data architectuser, in order to meet various goals for partitioning data.

FIG. 4 is a flow diagram illustrating query routing, according to anexample of the present disclosure. The method 400 may be performed byprocessing logic that may comprise hardware (e.g., circuitry, dedicatedlogic, programmable logic and microcode), software (such as instructionsrun on a computer system, specialized hardware, dedicated machine, orprocessing device), firmware, or a combination thereof.

At block 401, the source router receives a query, such as a source queryand analyzes source queries to determine where to route the sourcequery. The analysis includes determining a source column constant pairthat corresponds to the source query. The source column constant pairmay be determined in a similar way as the determining of historicalquery column constant pairs as described in block 306 of regarding FIG.3.

At block 402, the source router determines the data table that storesthe data corresponding to the data requested by the source query. If thetable is not partitioned, then at 404 the source query may be sent tothe data source that contains the table. The data source that containsthe table may receive the source query, process the source query usingthe data table to determine a source query response that contains thesource query results, and send the source query response to the datafederation tool.

If the table is partitioned, such that data from the table is split intotwo or more data subsets that are stored in sub-tables, then adetermination is made at step 406 whether the source query contains anyOR conditions. If the source query contains OR conditions, then thesource query may be retrieved at block 408 from a view by the datafederation tool.

If at block 406, a determination is made that that source query isassociated with a column constant pair that is incomparable to thecolumn constant pair associated with the table that stores the requesteddata, then the source query is retrieved at block 408 from a view by thedata federation tool.

At block 410, if the column constant pair associated with the sourcequery is determined to have a pre-defined relation, which in thisexample is “less or equal to” the partitioning column constant pairassociated with the table, then the source query is sent to the firstsub-table of the table that stores a first subset of the data set atblock 412.

At block 414, if the column constant pair associated with the sourcequery is determined to have a pre-defined relation, which in thisexample is “greater than” the partitioning column constant pairassociated with the table, then the source query is sent to the secondsub-table of the table that stores a second subset of the data set atblock 416.

In another example, instead of the “less than or equal to” and “greaterthan” relations, other relations may be pre-defined by a user. Forexample, the source queries that have a column constant pair “greaterthan or equal to” a partitioning column constant pair associated with atable may be routed to one sub-table and source queries that have acolumn constant pair that is “less than” a column constant pairassociated with the table may be routed to another sub-table.

Routing the source queries based on the column constant pairs allowssource query results to be determined from less subsets of data,therefore reducing the amount of data that is required to be searched.The partitioning of data results in optimized query efficiency andimproved query processing functionality.

FIG. 5 illustrates a diagram of a machine in the exemplary form of acomputer system 500 within which a set of instructions, for causing themachine to perform any one or more of the methodologies discussedherein, may be executed. In other examples, the machine may be connected(e.g., networked) to other machines in a LAN, an intranet, an extranet,or the Internet. The machine may operate in the capacity of a server ora client machine in client-server network environment, or as a peermachine in a peer-to-peer (or distributed) network environment. Themachine may be a personal computer (PC), a tablet PC, a set-top box(STB), a Personal Digital Assistant (PDA), a cellular telephone, a webappliance, a server, a network router, switch or bridge, or any machinecapable of executing a set of instructions (sequential or otherwise)that specify actions to be taken by that machine. Further, while asingle machine is illustrated, the term “machine” shall also be taken toinclude any collection of machines that individually or jointly executea set (or multiple sets) of instructions to perform any one or more ofthe methodologies discussed herein.

Exemplary computer system 500 includes processing device (processor)502, main memory 504 (e.g., read-only memory (ROM), flash memory,dynamic random access memory (DRAM) such as synchronous DRAM (SDRAM),double data rate (DDR SDRAM), or DRAM (RDRAM), and so forth), staticmemory 506 (e.g., flash memory, static random access memory (SRAM), andso forth), and data storage device 518, which communicate with eachother via bus 530.

Processor 502 represents one or more general-purpose processing devicessuch as a microprocessor, central processing unit, or the like.

More particularly, processor 502 may be a complex instruction setcomputing (CISC) microprocessor, reduced instruction set computing(RISC) microprocessor, very long instruction word (VLIW) microprocessor,or a processor implementing other instruction sets or processorsimplementing a combination of instruction sets. Processor 502 may alsobe one or more special-purpose processing devices such as an applicationspecific integrated circuit (ASIC), a field programmable gate array(FPGA), a digital signal processor (DSP), network processor, or thelike. Processor 502 is configured to execute instructions for performingthe operations and steps discussed herein.

Computer system 500 may further include network interface device 508.

Computer system 500 also may include video display unit 510 (e.g., aliquid crystal display (LCD) or a cathode ray tube (CRT)), alphanumericinput device 512 (e.g., a keyboard), cursor control device 514 (e.g., amouse), and signal generation device 516 (e.g., a speaker).

Data storage device 518 may include a computer-readable storage mediumon which is stored one or more sets of instructions (e.g., software)embodying any one or more of the methodologies or functions describedherein. The instructions may also reside, completely or at leastpartially, within main memory 504 and/or within processor 502 duringexecution thereof by computer system 500, main memory 504 and processor502 also constituting computer-readable storage media. The instructionsmay further be transmitted or received over network 520 via networkinterface device 508.

While data storage device 518 is shown in an example to be a singlemedium, the term “data storage device” should be taken to include asingle medium or multiple media (e.g., a centralized or distributeddatabase, and/or associated caches and servers) that store the one ormore sets of instructions.

The term “computer-readable storage medium” shall also be taken toinclude any medium that is capable of storing, encoding or carrying aset of instructions for execution by the machine and that cause themachine to perform any one or more of the methodologies of the presentdisclosure. The term “computer-readable storage medium” shallaccordingly be taken to include, but not be limited to, solid-statememories, optical media, and magnetic media.

In the foregoing description, numerous details are set forth. It will beapparent, however, to one of ordinary skill in the art having thebenefit of this disclosure, that the present disclosure may be practicedwithout these specific details. In some instances, well-known structuresand devices are shown in block diagram form, rather than in detail, inorder to avoid obscuring the present disclosure.

Some portions of the detailed description have been presented in termsof algorithms and symbolic representations of operations on data bitswithin a computer memory. An algorithm is here, and generally, conceivedto be a self-consistent sequence of steps leading to a desired result.The steps are those requiring physical manipulations of physicalquantities. Usually, though not necessarily, these quantities take theform of electrical or magnetic signals capable of being stored,transferred, combined, compared, and otherwise manipulated. It hasproven convenient at times, for reasons of common usage, to refer tothese signals as bits, values, elements, symbols, characters, terms,numbers, or the like.

It should be borne in mind, however, that all of these and similar termsare to be associated with the appropriate physical quantities and aremerely convenient labels applied to these quantities. Unlessspecifically stated otherwise as apparent from the following discussion,it is appreciated that throughout the description, discussions utilizingterms such as “determining,” “measuring,” “generating,” “setting,”“performing,” “computing,” “comparing,” “applying,” “creating,”“ranking,” “classifying,” and the like, refer to the actions andprocesses of a computer system, or similar electronic computing device,that manipulates and transforms data represented as physical (e.g.,electronic) quantities within the computer system's registers andmemories into other data similarly represented as physical quantitieswithin the computer system memories or registers or other suchinformation storage, transmission or display devices.

Certain examples of the present disclosure also relate to an apparatusfor performing the operations herein. This apparatus may be constructedfor the intended purposes, or it may comprise a general-purpose computerselectively activated or reconfigured by a computer program stored inthe computer. Such a computer program may be stored in a computerreadable storage medium, such as, but not limited to, any type of diskincluding floppy disks, optical disks, CD-ROMs, and magnetic-opticaldisks, read-only memories (ROMs), random access memories (RAMs), EPROMs,EEPROMs, magnetic or optical cards, or any type of media suitable forstoring electronic instructions.

Although illustrative embodiments have been shown and described, a widerange of modification, change and substitution is contemplated in theforegoing disclosure and in some instances, some features of theembodiments may be employed without a corresponding use of otherfeatures. One of ordinary skill in the art would recognize manyvariations, alternatives, and modifications. Thus, the scope of theinvention should be limited only by the following claims, and it isappropriate that the claims be construed broadly and in a mannerconsistent with the scope of the embodiments disclosed herein.

What is claimed is:
 1. A computer-implemented method for federated queryprocessing comprising: receiving one or more source queries associatedwith a data set; storing the one or more source queries as one or morehistorical queries; determining one or more column constant pairsassociated with the one or more historical queries; based on the one ormore column constant pairs, determining a partitioning column constantpair; determining a first subset of the one or more column constantpairs that has a first pre-defined relation to the partitioning columnconstant pair; determining a second subset of the one or more columnconstant pairs that has a second pre-defined relation to thepartitioning column constant pair; based on the partitioning columnconstant pair, partitioning the data set into a first subset of the dataset and a second subset of the data set; receiving a source query;determining a source column constant pair associated with the sourcequery; comparing the source column constant pair to the partitioningcolumn constant pair; and based on the comparing, generating a result ofthe source query from at least one of the following: a view, the firstsubset of the data set, and the second subset of the data set.
 2. Themethod of claim 1 wherein (i) the first pre-defined relation is a “lessthan or equal to” relation and the second pre-defined relation is a“greater than” relation or (ii) the first pre-defined relation is a“less than” relation and the second pre-defined relation is a “greaterthan or equal to” relation.
 3. The method of claim 1, the comparingfurther comprising: routing the source query to the view if the sourcecolumn constant pair is determined to be incomparable to thepartitioning column constant pair; routing the source query to the firstsubset of the data set if the source column constant pair is determinedto have the first pre-defined relation to the partitioning columnconstant pair; and routing the source query to the second subset of thedata set if the source column constant pair is determined to have thesecond pre-defined relation to the partitioning column constant pair. 4.The method of claim 1 wherein the first subset of the data set islocated on a first data source and the second subset of the data set islocated on a second data source that is different than the first datasource.
 5. The method of claim 1 wherein the partitioning columnconstant pair is a tuple comprising at least one column identifier andat least one constant corresponding to the at least one columnidentifier.
 6. The method of claim 1 wherein a size of the first subsetof the one or more historical queries is within a pre-defined amount ofa size of the second subset of the one or more historical queries. 7.The method of claim 1 further comprising: determining a third subset ofthe one or more column constant pairs, wherein the third subset isdetermined to be incomparable to the partitioning column constant pair.8. The method of claim 1 wherein the first subset of the data set hasthe first pre-defined relation with respect to the partitioning columnconstant pair and the second subset of the data set has the secondpre-defined relation with respect to the partitioning column constantpair.
 9. A non-transitory computer-readable medium for query processingcomprising computer-readable instructions, the computer-readableinstructions executable by a processor to cause the processor to:receive a source query; determine a source column constant pairassociated with the source query; determine a partitioning columnconstant pair associated with a data set; compare the source columnconstant pair to the partitioning column constant pair; and based on thecomparison, determine a result of the source query from at least one ofthe following: a view, a first subset of the data set, and a secondsubset of the data set.
 10. The medium of claim 9 the processor furtherto: receive one or more source queries associated with the data set;store the one or more source queries as one or more historical queries;determine one or more column constant pairs associated with the one ormore historical queries; based on the one or more column constant pairs,determine the partitioning column constant pair; determine a firstsubset of the one or more column constant pairs that has a firstpre-defined relation to the partitioning column constant pair; determinea second subset of the one or more column constant pairs that has asecond pre-defined relation to the partitioning column constant pair;and based on the partitioning column constant pair, partition the dataset into a first subset of the data set and a second subset of the dataset.
 11. The medium of 9 wherein the partitioning column constant pairis a tuple comprising one or more column identifiers and one or moreconstants corresponding to the column identifiers.
 12. The medium ofclaim 10 wherein (i) the first pre-defined relation is a “less than orequal to” relation and the second pre-defined relation is a “greaterthan” relation or (ii) the first pre-defined relation is a “less than”relation and the second pre-defined relation is a “greater than or equalto” relation.
 13. The medium of claim 9 the processor further to: routethe source query to the view if the source column constant pair isdetermined to be incomparable to the partitioning column constant pair;route the source query to the first subset of the data set if the sourcecolumn constant pair is determined to have the first pre-definedrelation to the partitioning column constant pair; and route the sourcequery to the second subset of the data set if the source column constantpair is determined to have the second pre-defined relation to thepartitioning column constant pair.
 14. The medium of claim 10 theprocessor further to: determine a third subset of the one or more columnconstant pairs, wherein the third subset is incomparable to thepartitioning column constant pair.
 15. A federated system for queryprocessing, comprising: at least one processor in communication with amemory; a source router communicatively coupled to one or more datasources; the source router executable by the at least one processor to:receive a source query; determine a source column constant pairassociated with the source query; compare the source column constantpair to a partitioning column constant pair that is associated with adata set; and based on the comparison, determine a result of the sourcequery from at least one of the following: a view, a first subset of thedata set that is stored on a first data source of the one or more datasources, and a second subset of the data set that is stored on a seconddata source of the one or more data sources.
 16. The federated system ofclaim 15, further comprising: a multisource partitioner executable bythe at least one processor to: determine one or more column constantpairs associated with one or more historical queries; based on the oneor more column constant pairs, determine the partitioning columnconstant pair; determine a first subset of the one or more one or morecolumn constant pairs that has a first pre-defined relation to thepartitioning column constant pairs; determine a second subset of the oneor more one or more column constant pairs that has a second pre-definedrelation to the partitioning column constant pair; and based on thepartitioning column constant pair, partition the data set into a firstsubset of the data set and a second subset of the data set.
 17. Thefederated system of claim 15 wherein the partitioning column constantpair is a tuple comprising one or more column identifiers and one ormore constants corresponding to the column identifiers.
 18. Thefederated system of claim 16 wherein (i) the first pre-defined relationis a “less than or equal to” relation and the second pre-definedrelation is a “greater than” relation or (ii) the first pre-definedrelation is a “less than” relation and the second pre-defined relationis a “greater than or equal to” relation.
 19. The federated system ofclaim 15, the source router further to: route the source query to theview if the source column constant pair is determined to be incomparableto the partitioning column constant pair; route the source query to thefirst subset of the data set if the source column constant pair isdetermined to have the first pre-defined relation to the partitioningcolumn constant pair; and route the source query to the second subset ofthe data set if the source column constant pair associated with a sourcequery is determined to have the second pre-defined relation to thepartitioning column constant pair.
 20. The federated system of claim 16the multisource partitioner further to: determine a third subset of theone or more column constant pairs, wherein the third subset isdetermined to be incomparable to the partitioning column constant pair.